In [2]:
import networkx as nx
from datetime import datetime
import matplotlib.pyplot as plt
import numpy as np
import warnings
from custom import custom_funcs as cf
warnings.filterwarnings('ignore')
%load_ext autoreload
%autoreload 2
%matplotlib inline
As mentioned earlier, networks, also known as graphs, are comprised of individual entities and their representatives. The technical term for these are nodes and edges, and when we draw them we typically use circles (nodes) and lines (edges).
In this notebook, we will work with a social network of seventh graders, in which nodes are individual students, and edges represent their relationships. Edges between individuals show how often the seventh graders indicated other seventh graders as their favourite.
Data credit: http://konect.uni-koblenz.de/networks/moreno_seventh
In the networkx implementation, graph objects store their data in dictionaries.
Nodes are part of the attribute Graph.node, which is a dictionary where the key is the node ID and the values are a dictionary of attributes.
Edges are part of the attribute Graph.edge, which is a nested dictionary. Data are accessed as such: G.edge[node1][node2]['attr_name'].
Because of the dictionary implementation of the graph, any hashable object can be a node. This means strings and tuples, but not lists and sets.
Let's load some real network data to get a feel for the NetworkX API. This dataset comes from a study of 7th grade students.
This directed network contains proximity ratings between studetns from 29 seventh grade students from a school in Victoria. Among other questions the students were asked to nominate their preferred classmates for three different activities. A node represents a student. An edge between two nodes shows that the left student picked the right student as his answer. The edge weights are between 1 and 3 and show how often the left student chose the right student as his favourite.
In [3]:
G = cf.load_seventh_grader_network()
In [4]:
# Who are represented in the network?
G.nodes()
Out[4]:
In [5]:
len(G.nodes())
# len(G)
Out[5]:
Let's now figure out who is connected to who in the network
In [6]:
# Who is connected to who in the network?
G.edges()
Out[6]:
In [6]:
len(G.edges())
Out[6]:
A network, more technically known as a graph, is comprised of:
They can be represented as two lists:
Since this is a social network of people, there'll be attributes for each individual, such as a student's gender. We can grab that data off from the attributes that are stored with each node.
In [7]:
# Let's get a list of nodes with their attributes.
G.nodes(data=True)
# NetworkX will return a list of tuples in the form (node_id, attribute_dictionary)
Out[7]:
In [8]:
from collections import Counter
mf_counts = Counter([d['gender'] for n, d in G.nodes(data=True)])
def test_answer(mf_counts):
assert mf_counts['female'] == 17
assert mf_counts['male'] == 12
test_answer(mf_counts)
Edges can also store attributes in their attribute dictionary.
In [9]:
G.edges(data=True)
Out[9]:
In this synthetic social network, the number of times the left student indicated that the right student was their favourite is stored in the "count" variable.
In [10]:
# Answer
counts = [d['count'] for _, _, d in G.edges(data=True)]
maxcount = max(counts)
def test_maxcount(maxcount):
assert maxcount == 3
test_maxcount(maxcount)
We found out that there are two individuals that we left out of the network, individual no. 30 and 31. They are one male (30) and one female (31), and they are a pair that just love hanging out with one another and with individual 7 (count=3), in both directions per pair. Add this information to the graph.
If you need more help, check out https://networkx.readthedocs.io/en/stable/tutorial/index.html
In [11]:
# Answer
G.add_node(30, gender='male')
G.add_node(31, gender='female')
G.add_edge(30, 31, count=3)
G.add_edge(31, 30, count=3)
G.add_edge(30, 7, count=3)
G.add_edge(7, 30, count=3)
G.add_edge(31, 7, count=3)
G.add_edge(7, 31, count=3)
Verify that you have added in the edges and nodes correctly by running the following cell.
In [12]:
def test_graph_integrity(G):
assert 30 in G.nodes()
assert 31 in G.nodes()
assert G.node[30]['gender'] == 'male'
assert G.node[31]['gender'] == 'female'
assert G.has_edge(30, 31)
assert G.has_edge(30, 7)
assert G.has_edge(31, 7)
assert G.edge[30][7]['count'] == 3
assert G.edge[7][30]['count'] == 3
assert G.edge[31][7]['count'] == 3
assert G.edge[7][31]['count'] == 3
assert G.edge[30][31]['count'] == 3
assert G.edge[31][30]['count'] == 3
print('All tests passed.')
test_graph_integrity(G)
A note about the tests: Testing is good practice when writing code. Well-crafted assertion statements help you program defensivel, by forcing you to explicitly state your assumptions about the code or data.
For more references on defensive programming, check out Software Carpentry's website: http://swcarpentry.github.io/python-novice-inflammation/08-defensive.html
For more information on writing tests for your data, check out these slides from a lightning talk I gave at Boston Python and SciPy 2015: http://j.mp/data-test
A similar pattern can be used for edges:
[n2 for n1, n2, d in G.edges(data=True)]
or
[n2 for _, n2, d in G.edges(data=True)]
If the graph you are constructing is a directed graph, with a "source" and "sink" available, then I would recommend the following pattern:
[(sc, sk) for sc, sk, d in G.edges(data=True)]
or
[d['attr'] for sc, sk, d in G.edges(data=True)]
In [13]:
nx.draw(G)
If the network is small enough to visualize, and the node labels are small enough to fit in a circle, then you can use the with_labels=True argument.
In [14]:
nx.draw(G, with_labels=True)
However, note that if the number of nodes in the graph gets really large, node-link diagrams can begin to look like massive hairballs. This is undesirable for graph visualization.
Instead, we can use a matrix to represent them. The nodes are on the x- and y- axes, and a filled square represent an edge between the nodes. This is done by using the nx.to_numpy_matrix(G) function.
We then use matplotlib's pcolor(numpy_array) function to plot. Because pcolor cannot take in numpy matrices, we will cast the matrix as an array of arrays, and then get pcolor to plot it.
In [15]:
matrix = nx.to_numpy_matrix(G)
plt.pcolor(np.array(matrix))
plt.axes().set_aspect('equal') # set aspect ratio equal to get a square visualization
plt.xlim(min(G.nodes()), max(G.nodes())) # set x and y limits to the number of nodes present.
plt.ylim(min(G.nodes()), max(G.nodes()))
plt.title('Adjacency Matrix')
plt.show()
Let's try another visualization, the Circos plot. We can order the nodes in the Circos plot according to the node ID, but any other ordering is possible as well. Edges are drawn between two nodes.
Credit goes to Justin Zabilansky (MIT) for the implementation, and Jon Charest for improvements.
In [16]:
from circos import CircosPlot
fig = plt.figure(figsize=(6,6))
ax = fig.add_subplot(111)
nodes = sorted(G.nodes())
edges = G.edges()
node_cmap = {'male':'blue', 'female':'red'}
nodecolors = [node_cmap[G.node[n]['gender']] for n in G.nodes()]
c = CircosPlot(nodes, edges, radius=10, ax=ax, fig=fig, nodecolor=nodecolors)
c.draw()
plt.savefig('images/seventh.png', dpi=300)
This visualization helps us highlight nodes that there are poorly connected, and others that are strongly connected.
Next up, let's try Hive Plots.
In [17]:
from hiveplot import HivePlot
nodes = dict()
nodes['male'] = [n for n,d in G.nodes(data=True) if d['gender'] == 'male']
nodes['female'] = [n for n,d in G.nodes(data=True) if d['gender'] == 'female']
edges = dict()
edges['group1'] = G.edges(data=True)
nodes_cmap = dict()
nodes_cmap['male'] = 'blue'
nodes_cmap['female'] = 'red'
edges_cmap = dict()
edges_cmap['group1'] = 'black'
In [18]:
h = HivePlot(nodes, edges, nodes_cmap, edges_cmap)
h.draw()
Hive plots allow us to divide our nodes into sub-groups, and visualize the within- and between-group connectivity.
In [ ]: